package com.ffggffgfv.backend.service.impl;

import com.ffggffgfv.backend.dto.*;
import com.ffggffgfv.backend.entity.Merchant;
import com.ffggffgfv.backend.entity.Product;
import com.ffggffgfv.backend.mapper.MerchantMapper;
import com.ffggffgfv.backend.mapper.OrderMapper;
import com.ffggffgfv.backend.mapper.ProductMapper;
import com.ffggffgfv.backend.mapper.ShelfMapper;
import com.ffggffgfv.backend.service.MerchantService;
import com.ffggffgfv.backend.service.ProductService;
import com.ffggffgfv.backend.util.JWTUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.*;
import java.util.logging.Logger;

/**
 * 商家服务实现类
 */
@Service
public class MerchantServiceImpl implements MerchantService {

    private static final Logger logger = Logger.getLogger(MerchantServiceImpl.class.getName());

    @Autowired
    private MerchantMapper merchantMapper;

    @Autowired
    private ProductMapper productMapper;

    @Autowired
    private ShelfMapper shelfMapper;

    @Autowired
    private OrderMapper orderMapper;

    @Autowired
    private ProductService productService;

    @Autowired
    private BCryptPasswordEncoder passwordEncoder;

    @Autowired
    private JWTUtil jwtUtil;

    /**
     * 商家登录
     *
     * @param loginDTO 登录信息
     * @return 登录结果
     */
    @Override
    public Map<String, Object> login(MerchantLoginDTO loginDTO) {
        // 根据用户名查询商家
        Merchant merchant = merchantMapper.selectByUsername(loginDTO.getUsername());

        // 验证商家是否存在且密码是否正确
        if (merchant == null || !passwordEncoder.matches(loginDTO.getPassword(), merchant.getPassword())) {
            return null;
        }

        // 验证账号状态是否正常
        if (merchant.getStatus() != null && merchant.getStatus() != 1) {
            return null;
        }

        // 设置角色
        List<String> roles = new ArrayList<>();
        roles.add("ROLE_MERCHANT");

        // 生成JWT令牌
        String token = jwtUtil.generateToken(merchant.getUsername(), merchant.getId(), roles);

        // 返回结果
        Map<String, Object> result = new HashMap<>();
        result.put("token", token);
        result.put("merchantId", merchant.getId());
        result.put("username", merchant.getUsername());
        result.put("name", merchant.getName());
        result.put("avatarUrl", merchant.getAvatarUrl());
        result.put("roles", roles);

        return result;
    }

    /**
     * 通过ID获取商家信息
     *
     * @param id 商家ID
     * @return 商家详细信息
     */
    @Override
    public MerchantInfoDTO getMerchantInfo(Long id) {
        // 查询商家
        Merchant merchant = merchantMapper.selectById(id);
        if (merchant == null) {
            return null;
        }

        // 构建商家信息DTO
        MerchantInfoDTO merchantInfoDTO = new MerchantInfoDTO();
        merchantInfoDTO.setId(merchant.getId());
        merchantInfoDTO.setUsername(merchant.getUsername());
        merchantInfoDTO.setName(merchant.getName());
        merchantInfoDTO.setContact(merchant.getContact());
        merchantInfoDTO.setPhone(merchant.getPhone());
        merchantInfoDTO.setAddress(merchant.getAddress());
        merchantInfoDTO.setStatus(merchant.getStatus());
        merchantInfoDTO.setAvatarUrl(merchant.getAvatarUrl());
        merchantInfoDTO.setCreateTime(merchant.getCreateTime());

        // 商家拥有的货架数量
        int shelfCount = shelfMapper.countByMerchantId(id);
        merchantInfoDTO.setShelfCount(shelfCount);

        // 商家拥有的商品数量
        int productCount = productMapper.countByMerchantId(id);
        merchantInfoDTO.setProductCount(productCount);

        return merchantInfoDTO;
    }

    /**
     * 通过ID获取商家实体
     *
     * @param id 商家ID
     * @return 商家实体
     */
    @Override
    public Merchant findById(Long id) {
        return merchantMapper.selectById(id);
    }

    /**
     * 通过用户名获取商家实体
     *
     * @param username 用户名
     * @return 商家实体
     */
    @Override
    public Merchant findByUsername(String username) {
        return merchantMapper.selectByUsername(username);
    }

    /**
     * 分页查询商家列表
     *
     * @param name     商家名称（可选）
     * @param status   状态（可选）
     * @param pageNum  页码
     * @param pageSize 每页数量
     * @return 分页结果
     */
    @Override
    public PageResult<Merchant> findByPage(String name, Integer status, int pageNum, int pageSize) {
        // 计算偏移量
        int offset = (pageNum - 1) * pageSize;

        // 查询总数
        long total = merchantMapper.countByCondition(name, status);

        // 查询当前页数据
        List<Merchant> merchants = merchantMapper.selectByPage(name, status, offset, pageSize);

        // 返回分页结果
        return new PageResult<>(merchants, total, pageNum, pageSize);
    }

    /**
     * 商家注册
     *
     * @param registerDTO 注册信息
     * @return 注册成功的商家信息
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public Merchant register(MerchantRegisterDTO registerDTO) {
        // 1. 创建商家实体
        Merchant merchant = new Merchant();
        merchant.setUsername(registerDTO.getUsername());
        merchant.setPassword(passwordEncoder.encode(registerDTO.getPassword()));
        merchant.setName(registerDTO.getName());
        merchant.setContact(registerDTO.getContact());
        merchant.setPhone(registerDTO.getPhone());
        merchant.setAddress(registerDTO.getAddress());

        // 2. 设置头像，如果没有提供则使用默认头像
        if (registerDTO.getAvatarUrl() == null || registerDTO.getAvatarUrl().trim().isEmpty()) {
            merchant.setAvatarUrl("/images/avatar/merchant_default.jpg");
        } else {
            merchant.setAvatarUrl(registerDTO.getAvatarUrl());
        }

        // 3. 设置状态为待审核
        merchant.setStatus(0);  // 0表示待审核，审核通过后管理员修改为1

        // 4. 设置创建和更新时间
        Date now = new Date();
        merchant.setCreateTime(now);
        merchant.setUpdateTime(now);

        // 5. 插入数据
        merchantMapper.insert(merchant);

        return merchant;
    }

    /**
     * 判断用户名是否已存在
     *
     * @param username 用户名
     * @return 是否存在
     */
    @Override
    public boolean isUsernameExists(String username) {
        return merchantMapper.selectByUsername(username) != null;
    }

    /**
     * 判断手机号是否已存在
     *
     * @param phone 手机号
     * @return 是否存在
     */
    @Override
    public boolean isPhoneExists(String phone) {
        return merchantMapper.selectByPhone(phone) != null;
    }

    /**
     * 更新商家信息
     *
     * @param id        商家ID
     * @param updateDTO 更新信息
     * @return 更新后的商家
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public Merchant updateMerchant(Long id, MerchantUpdateDTO updateDTO) {
        // 查询原商家
        Merchant existingMerchant = merchantMapper.selectById(id);
        if (existingMerchant == null) {
            return null;
        }

        // 如果修改密码
        if (updateDTO.getOldPassword() != null && updateDTO.getNewPassword() != null) {
            // 验证旧密码
            if (!passwordEncoder.matches(updateDTO.getOldPassword(), existingMerchant.getPassword())) {
                return null;
            }

            // 更新密码
            String encodedPassword = passwordEncoder.encode(updateDTO.getNewPassword());
            merchantMapper.updatePassword(id, encodedPassword, new Date());
        }

        // 创建更新对象
        Merchant merchant = new Merchant();
        merchant.setId(id);

        // 设置需要更新的字段
        if (updateDTO.getName() != null) {
            merchant.setName(updateDTO.getName());
        }

        if (updateDTO.getContact() != null) {
            merchant.setContact(updateDTO.getContact());
        }

        if (updateDTO.getPhone() != null) {
            merchant.setPhone(updateDTO.getPhone());
        }

        if (updateDTO.getAddress() != null) {
            merchant.setAddress(updateDTO.getAddress());
        }

        if (updateDTO.getAvatarUrl() != null) {
            merchant.setAvatarUrl(updateDTO.getAvatarUrl());
        }

        merchant.setUpdateTime(new Date());

        // 更新商家信息
        merchantMapper.update(merchant);

        return merchantMapper.selectById(id);
    }

    /**
     * 修改商家状态
     *
     * @param id     商家ID
     * @param status 状态（0-停用 1-启用）
     * @return 是否成功
     */
    @Override
    public boolean updateStatus(Long id, Integer status) {
        // 查询原商家
        Merchant existingMerchant = merchantMapper.selectById(id);
        if (existingMerchant == null) {
            return false;
        }

        // 更新状态
        return merchantMapper.updateStatus(id, status, new Date()) > 0;
    }

    /**
     * 获取商家的商品列表
     *
     * @param merchantId 商家ID
     * @param pageNum    页码
     * @param pageSize   每页数量
     * @return 分页结果
     */
    @Override
    public PageResult<Product> getMerchantProducts(Long merchantId, int pageNum, int pageSize) {
        ProductQueryDTO queryDTO = new ProductQueryDTO();
        queryDTO.setMerchantId(merchantId);
        queryDTO.setPageNum(pageNum);
        queryDTO.setPageSize(pageSize);

        return productService.findByPage(queryDTO);
    }

    /**
     * 获取商家统计信息
     *
     * @param merchantId 商家ID
     * @return 统计信息
     */
    @Override
    public Map<String, Object> getStatistics(Long merchantId) {
        Map<String, Object> statistics = new HashMap<>();

        // 商品总数
        int productCount = productMapper.countByMerchantId(merchantId);
        statistics.put("productCount", productCount);

        // 上架商品数
        int onSaleCount = productMapper.countByMerchantIdAndStatus(merchantId, 1);
        statistics.put("onSaleCount", onSaleCount);

        // 货架总数
        int shelfCount = shelfMapper.countByMerchantId(merchantId);
        statistics.put("shelfCount", shelfCount);

        // 订单总数
        int orderCount = orderMapper.countByMerchantId(merchantId);
        statistics.put("orderCount", orderCount);

        // 待处理订单数
        int pendingOrderCount = orderMapper.countByMerchantIdAndStatus(merchantId, 1);  // 状态1表示已支付，待发货
        statistics.put("pendingOrderCount", pendingOrderCount);

        // 商品分类统计
        List<Map<String, Object>> categoryStat = productMapper.statByMerchantIdGroupByCategory(merchantId);
        statistics.put("categoryStat", categoryStat);

        // 近7日订单统计
        List<Map<String, Object>> orderStat = orderMapper.statByMerchantIdGroupByDate(merchantId, 7);
        statistics.put("orderStat", orderStat);

        return statistics;
    }

    /**
     * 查询所有商家
     *
     * @return 商家列表
     */
    @Override
    public List<Merchant> findAll() {
        return merchantMapper.selectAll();
    }
}
